// 内置类型: any, unknown, nerver

// any 定义不清晰数据源类型
// unknown 可重新定义签名
// nerver 虚无, 用来处理bug

// 类型断言: 警告编译器不准报错
let unknownVar: unknown;
(unknownVar as { foo: () => {} }).foo();
// 使用as 到 any , 跳过类型检查
const str: string = "azyyz";
(str as any).func().foo().prop;

// 非空断言
// declare const foo :{
//     func?:()=>({
//         prop?:number | null;
//     })
// };
// foo.func().prop.toFixed();

// 类型别名
type A = string;
// 类型 接口
type StatusCode = 200 | 301 | 400 | 500 | 502;
type PossibleDataTypes = string | number | (() => unknown);

//
const statuss: StatusCode = 502;
// 联合类型 与 交叉类型

// 交叉类型
interface NameStruct {
  name: string;
}
interface AgeStruct {
  age: number;
}
type ProfileStruct = NameStruct & AgeStruct;

const profile: ProfileStruct = {
  name: "azyyz",
  age: 111,
};

// 对象类型合并
type StrAndNum = string & number; // nerver

// 交叉类型的合并
type Struct1 = {
  primitiveProp: string;
  objectProp: {
    name: string;
  };
};
type Struct2 = {
  primitiveProp: number;
  objectProp: {
    age: number;
  };
};

// 两个type (接口) 合并
type Composed = Struct1 & Struct2;
type primitivePropType = Composed["primitiveProp"]; // nerver 虚无类型
type objectPropType = Composed["objectProp"]; // {name:string;age:number}

// 两边联合类型合并的交集;
type UnionIntersection1 = (1 | 2 | 3) & (1 | 2);
type UnionIntersection2 = (string | number | symbol) & string; // string

// 索引类型
// 快速生命 键值类型 一致 的类型结构
interface AllStringTypesFace {
  [key: string]: string;
}
type AllStringTypesType = {
  [key: string]: string;
};

//
const fooFour: AllStringTypesType = {
  linbudu: "恩格尔系数大佬",
  111: "azyyz",
  [Symbol("ddd")]: "symbol,",
};

// interface 的声明 可以这样写
interface StringOrBooleanTypes {
  propA: number;
  propB: boolean;
  [key: string]: number | boolean;
}

// 索引类型查询  keyof 关键字
interface Foo {
  azyyz: 1;
  599: 2;
}
type Fookeys = keyof Foo;

// 索引类型访问
interface NumberRecord {
  [key: string]: number;
}
type PropType = NumberRecord[string]; // number

interface Foo {
  propS: number;
  propN: boolean;
}
type PropAType = Foo['propS']; // number 
type PropBType = Foo['propN']; // boolean

// 映射类型: 类型编程 的 第一步
type Stringify<T> = {
    [K in keyof T] : string;
}

interface Foo123 {
    prop23:string;
    prop34:number;
    prop345:boolean;
    prop2345:()=>void;
}

type StringifedFoo = Stringify<Foo>;
// || V
// 等价于
interface StringifiedFoo123{
    prop123:string;
}